﻿using MediatR;
using Microsoft.EntityFrameworkCore;
using W.Common.Enum;
using W.Purchase.API.Application.Command.ProcurementCommand;
using W.Purchase.Domain;
using W.Purchase.Repository.Interface;

namespace W.Purchase.API.Application.CommandHandler.ProcurementCommandHandler
{
    public class ReturnCreateCommandHandler : IRequestHandler<ReturnCreateCommand, ApiResult<int>>
    {
        private readonly ILogger<ReturnCreateCommandHandler> _logger;
        private readonly IProcurementRepository _procurementRepository;
        private readonly IBuyProductsRepository _buyProductsRepository;
        //private readonly IReturnsRepository _returnsRepository;
        //private readonly IProductsReturnsRepository _productsReturnsRepository;
        public ReturnCreateCommandHandler(ILogger<ReturnCreateCommandHandler> logger, IProcurementRepository procurementRepository, IBuyProductsRepository buyProductsRepository)
        {
            _logger = logger;
            _procurementRepository = procurementRepository;
            _buyProductsRepository = buyProductsRepository;
            //_returnsRepository = returnsRepository;//, IReturnsRepository returnsRepository, IProductsReturnsRepository productsReturnsRepository
            //_productsReturnsRepository = productsReturnsRepository;
        }
        public async Task<ApiResult<int>> Handle(ReturnCreateCommand request, CancellationToken cancellationToken)
        {
            ApiResult<int> result = new ApiResult<int>();
            try
            {
                var list = await _buyProductsRepository.GetAllAsaync();
                var slist = list.Where(c => c.BuyProductsId == request.BuyProductsId).FirstOrDefault();
                if (slist != null)
                {
                    slist.ReturnsNum = request.ReturnsNum;
                    if (request.ReturnsNum <= slist.BuyProductsNum)
                    {
                        slist.BuyProductsNum -= request.ReturnsNum;
                        slist.BuyProductsTotal -= (slist.Price * request.ReturnsNum);
                        if (slist.ReturnsNum == 0)
                        {
                            slist.ProcurementState = ProcurementState.订单取消;
                        }
                        else
                        {
                            slist.ProcurementState = ProcurementState.部分入库;
                        }
                        slist.IsReturn = true;
                        slist.ReturnNo = DateTime.Now.ToString("yyyyMMddHHmmss");
                        slist.UpdateTime = DateTime.Now;
                        result.Code = await _buyProductsRepository.Update(slist);
                        result.Message = "采购退货功成功";
                    }
                    else
                    {
                        result.Code = -2;
                        result.Message = "采购数量不能小于退货数量";
                    }
                }
                _logger.LogInformation("采购退货功能成功");
            }
            catch (Exception el)
            {
                result.Code = -1;
                result.Message = el.Message;
                _logger.LogError(el, el.Message);
                //throw;
            }
            return result;

            #region
            //System.Data.IsolationLevel.Serializable
            //using (var tran = _returnsRepository.DB.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
            //{
            //    try
            //    {
            //        //采购表添加一条数据
            //        var now = DateTime.Now;
            //        Returns returns = new Returns()
            //        {
            //            ReturnsNo = request.ReturnsNo,
            //            ProductName = request.ProductName,
            //            ProductNo = request.ProductNo,
            //            ProductSpec = request.ProductSpec,
            //            UnitName = request.UnitName,
            //            Price = request.Price,
            //            ReturnsNum = request.ReturnsNum,
            //            ReturnsTotal = request.ReturnsTotal,
            //            ProcurementNo = request.ProcurementNo,
            //            VendorName = request.VendorName,
            //            ReturnsState = ProcurementState.订单取消,
            //            CreateTime = now,
            //            office_id = request.office_id,
            //            user_id = request.user_id,
            //            IsDelete = false,
            //        };
            //        await _returnsRepository.AddAsync(returns);
            //        //给采购产品信息添加
            //        foreach (var item in request.ProductsReturns)
            //        {
            //            ProductsReturns productsReturns = new ProductsReturns()
            //            {
            //                ProcurementNo = returns.ProcurementNo,
            //                ReturnsNo = returns.ReturnsNo,
            //                office_id = returns.office_id,
            //                user_id = returns.user_id,
            //                CreateTime = now,
            //                IsDelete = false,
            //            };
            //            await _productsReturnsRepository.AddAsync(productsReturns);
            //        }
            //        //采购数量 = 采购数量-退货数量
            //        //给采购产品信息添加
            //        foreach (var item in request.ProcurementDeltils)
            //        {
            //            // 根据采购单号查找对应的采购记录
            //            var procurement = (await _procurementRepository.GetAllAsaync()).Where(p => p.ProcurementNo == returns.ProcurementNo && p.IsDelete == false).FirstOrDefault();
            //            if (procurement == null)
            //            {
            //                result.Message = "未找到对应的采购记录";
            //                result.Code = -2;
            //                _logger.LogError(new Exception(result.Message), result.Message);
            //                tran.Rollback();
            //                return result;
            //            }
            //            // 根据采购记录关联的采购产品记录（通过 ProcurementId 关联）
            //            var buyProducts = (await _buyProductsRepository.GetAllAsaync()).Where(bp => bp.ProcurementId == procurement.ProcurementId && bp.IsDelete == false).FirstOrDefault();


            //            if (buyProducts == null)
            //            {
            //                result.Message = "未找到对应的采购产品记录";
            //                result.Code = -3;
            //                _logger.LogError(new Exception(result.Message), result.Message);
            //                tran.Rollback();
            //                return result;
            //            }
            //            if (buyProducts == null)
            //                // 检查退货数量是否超过采购数量
            //                if (request.ReturnsNum > buyProducts.BuyProductsNum)
            //                {
            //                    result.Message = "退货数量不能超过采购数量";
            //                    result.Code = -4;
            //                    _logger.LogError(new Exception(result.Message), result.Message);
            //                    tran.Rollback();
            //                    return result;
            //                }

            //            // 更新采购记录状态
            //            procurement.ProcurementState = ProcurementState.订单取消;
            //            procurement.IsReturn = true;

            //            // 更新采购产品数量
            //            buyProducts.BuyProductsNum -= request.ReturnsNum;
            //            //var procurements = (from a in await _procurementRepository.GetAllAsaync()
            //            //                   join b in await _buyProductsRepository.GetAllAsaync() on a.ProcurementId equals b.ProcurementId
            //            //                   where a.ProcurementNo == returns.ProcurementNo && a.IsDelete == false && b.IsDelete == false
            //            //                   select new ProcurementDeltil
            //            //                   {
            //            //                       ProcurementState = a.ProcurementState,
            //            //                       IsReturn = a.IsReturn,
            //            //                       BuyProductsNum = b.BuyProductsNum,
            //            //                   }).FirstOrDefault();
            //            //if (procurement != null)
            //            //{
            //            //    procurement.ProcurementState = ProcurementState.订单取消;
            //            //    procurement.IsReturn = true;
            //            //    if(procurement.BuyProductsNum> request.ReturnsNum)
            //            //    {
            //            //        procurement.BuyProductsNum = procurement.BuyProductsNum - request.ReturnsNum;
            //            //    }
            //            //    else
            //            //    {
            //            //        result.Message = "退货数量不能超过采购数量";
            //            //    }

            //            //}
            //            await _procurementRepository.Update(procurement);
            //            await _buyProductsRepository.Update(buyProducts);
            //        }
            //        var list = await _returnsRepository.DB.SaveChangesAsync();
            //        tran.Commit();
            //        result.Code = list;
            //    }
            //    catch (Exception el)
            //    {
            //        result.Code = -1;
            //        result.Message = el.Message;
            //        _logger.LogError(el, el.Message);
            //        tran.Rollback();
            //    }
            //}
            #endregion
        }

        //public async Task<ApiResult<int>> Handle(ReturnCreateCommand request, CancellationToken cancellationToken)
        //{
        //    ApiResult<int> result = new ApiResult<int>();
        //    try
        //    {
        //        // 从仓储获取所有采购商品数据
        //        var list = await _buyProductsRepository.GetAllAsaync();

        //        // 筛选出符合退货条件（根据请求中的采购商品ID等匹配条件）的商品列表，此处改为批量获取符合条件的，而不是只取第一个
        //        var slist = list.Where(c => c.BuyProductsId == request.BuyProductsId).ToList();

        //        if (slist.Count > 0)
        //        {
        //            // 用于记录成功更新的记录数量
        //            int updatedCount = 0;

        //            foreach (var item in slist)
        //            {
        //                // 验证退货数量不能大于采购商品现有的数量，此处修复原代码比较逻辑错误
        //                if (request.ReturnsNum <= item.BuyProductsNum)
        //                {
        //                    if (item.ReturnsNum == null)
        //                    {
        //                        item.ReturnsNum = request.ReturnsNum;
        //                        item.ReturnNo = DateTime.Now.ToString("yyyyMMddHHmmss");
        //                    }
        //                    else
        //                    {
        //                        item.ReturnsNum += request.ReturnsNum;
        //                    }
        //                    item.BuyProductsNum -= request.ReturnsNum;
        //                    item.BuyProductsTotal -= (item.Price * request.ReturnsNum);
        //                    if (item.ReturnsNum == item.BuyProductsNum)
        //                    {
        //                        item.ProcurementState = ProcurementState.订单取消;
        //                    }
        //                    else
        //                    {
        //                        item.ProcurementState = ProcurementState.部分入库;
        //                    }
        //                    item.IsReturn = true;
        //                    item.UpdateTime = DateTime.Now;

        //                    // 调用仓储的更新方法更新单条记录，并累加成功更新的数量
        //                    int updateResult = await _buyProductsRepository.Update(item);
        //                    if (updateResult > 0)
        //                    {
        //                        updatedCount++;
        //                    }
        //                }
        //                else
        //                {
        //                    // 如果退货数量超出限制，记录错误信息并直接返回（这里可以根据实际需求决定是继续处理其他商品还是直接返回错误）
        //                    result.Code = -2;
        //                    result.Message = "退货数量不能大于采购数量";
        //                    return result;
        //                }
        //            }

        //            // 设置返回结果的状态码为成功更新的记录数量，可根据实际业务定义合适的返回值含义
        //            result.Code = updatedCount;
        //            result.Message = $"成功更新 {updatedCount} 条退货记录";
        //            _logger.LogInformation("采购退货功能成功，更新记录数：" + updatedCount);
        //        }
        //        else
        //        {
        //            result.Code = -3;
        //            result.Message = "未找到对应的采购商品记录，无法进行退货操作";
        //            _logger.LogInformation("未找到对应的采购商品记录，无法进行退货操作");
        //        }
        //    }
        //    catch (Exception el)
        //    {
        //        result.Code = -1;
        //        result.Message = el.Message;
        //        _logger.LogError(el, el.Message);
        //    }

        //    return result;
        //}
    }
}
